package com.stu.javabase;

/**
 * this、super关键字和循环控制演示
 * 涵盖：
 * - this和super的区别
 * - while和do-while的区别
 * - 循环跳出方式
 * - 逻辑运算符的区别
 * 
 * @author 学习者
 * @version 1.0
 */
public class KeywordsAndLoops {
    
    public static void main(String[] args) {
        System.out.println("=== this、super关键字和循环控制演示 ===");
        
        // 1. this和super关键字演示
        demonstrateThisAndSuper();
        
        // 2. while和do-while循环演示
        demonstrateWhileLoops();
        
        // 3. 循环跳出演示
        demonstrateLoopBreaking();
        
        // 4. 逻辑运算符演示
        demonstrateLogicalOperators();
    }
    
    /**
     * 演示this和super关键字的使用
     */
    private static void demonstrateThisAndSuper() {
        System.out.println("\n=== this和super关键字演示 ===");
        
        Child child = new Child("子类", 10);
        child.showInfo();
        child.callParentMethod();
    }
    
    /**
     * 演示while和do-while循环的区别
     */
    private static void demonstrateWhileLoops() {
        System.out.println("\n=== while和do-while循环演示 ===");
        
        // while循环：先判断条件，再执行循环体
        System.out.println("while循环（条件为false）：");
        int i = 5;
        while (i < 5) {
            System.out.println("while循环执行，i = " + i);
            i++;
        }
        System.out.println("while循环结束，循环体没有执行");
        
        // do-while循环：先执行循环体，再判断条件
        System.out.println("\ndo-while循环（条件为false）：");
        int j = 5;
        do {
            System.out.println("do-while循环执行，j = " + j);
            j++;
        } while (j < 5);
        System.out.println("do-while循环结束，循环体至少执行一次");
        
        // 正常循环演示
        System.out.println("\n正常while循环：");
        int k = 1;
        while (k <= 3) {
            System.out.println("while循环第" + k + "次执行");
            k++;
        }
        
        System.out.println("\n正常do-while循环：");
        int l = 1;
        do {
            System.out.println("do-while循环第" + l + "次执行");
            l++;
        } while (l <= 3);
    }
    
    /**
     * 演示循环跳出的各种方式
     */
    private static void demonstrateLoopBreaking() {
        System.out.println("\n=== 循环跳出演示 ===");
        
        // 1. break跳出单层循环
        System.out.println("\n1. break跳出单层循环：");
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                System.out.println("遇到5，使用break跳出循环");
                break;
            }
            System.out.println("i = " + i);
        }
        
        // 2. continue跳过当前迭代
        System.out.println("\n2. continue跳过当前迭代：");
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                System.out.println("遇到3，使用continue跳过");
                continue;
            }
            System.out.println("i = " + i);
        }
        
        // 3. 使用标签跳出多层嵌套循环
        System.out.println("\n3. 使用标签跳出多层嵌套循环：");
        outer: for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                if (i == 2 && j == 2) {
                    System.out.println("在i=2,j=2时跳出外层循环");
                    break outer; // 跳出外层循环
                }
                System.out.println("i=" + i + ", j=" + j);
            }
        }
        
        // 4. 使用return跳出方法
        System.out.println("\n4. 使用return跳出方法：");
        demonstrateReturnInLoop();
        
        // 5. 使用异常跳出循环（不推荐）
        System.out.println("\n5. 使用异常跳出循环（演示用，实际不推荐）：");
        try {
            for (int i = 1; i <= 10; i++) {
                if (i == 5) {
                    throw new RuntimeException("人为抛出异常跳出循环");
                }
                System.out.println("i = " + i);
            }
        } catch (RuntimeException e) {
            System.out.println("捕获异常：" + e.getMessage());
        }
    }
    
    /**
     * 演示在方法中使用return跳出循环
     */
    private static void demonstrateReturnInLoop() {
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                System.out.println("遇到5，使用return跳出方法");
                return; // 直接结束方法
            }
            System.out.println("i = " + i);
        }
        System.out.println("这行代码不会执行");
    }
    
    /**
     * 演示逻辑运算符&和&&的区别
     */
    private static void demonstrateLogicalOperators() {
        System.out.println("\n=== 逻辑运算符&和&&的区别演示 ===");
        
        // & 和 && 的区别
        System.out.println("\n&和&&的区别：");
        
        // 使用&&（短路与）
        System.out.println("使用&&（短路与）：");
        boolean result1 = false && isTrue("右侧表达式");
        System.out.println("false && isTrue() = " + result1);
        System.out.println("因为左侧为false，右侧方法不会被调用\n");
        
        // 使用&（逻辑与）
        System.out.println("使用&（逻辑与）：");
        boolean result2 = false & isTrue("右侧表达式");
        System.out.println("false & isTrue() = " + result2);
        System.out.println("即使左侧为false，右侧方法仍会被调用\n");
        
        // 位运算符&
        System.out.println("位运算符&的使用：");
        int a = 5;  // 二进制：101
        int b = 3;  // 二进制：011
        int result3 = a & b; // 二进制：001 = 1
        System.out.println(a + " & " + b + " = " + result3);
        System.out.println("二进制运算：101 & 011 = 001");
        
        // || 和 | 的区别
        System.out.println("\n||和|的区别：");
        
        // 使用||（短路或）
        System.out.println("使用||（短路或）：");
        boolean result4 = true || isTrue("右侧表达式");
        System.out.println("true || isTrue() = " + result4);
        System.out.println("因为左侧为true，右侧方法不会被调用\n");
        
        // 使用|（逻辑或）
        System.out.println("使用|（逻辑或）：");
        boolean result5 = true | isTrue("右侧表达式");
        System.out.println("true | isTrue() = " + result5);
        System.out.println("即使左侧为true，右侧方法仍会被调用");
    }
    
    /**
     * 辅助方法，用于演示短路运算
     * @param message 消息
     * @return 总是返回true
     */
    private static boolean isTrue(String message) {
        System.out.println("执行isTrue方法：" + message);
        return true;
    }
}

/**
 * 父类，用于演示this和super关键字
 */
class Parent {
    protected String name;
    protected int value;
    
    /**
     * 父类构造方法
     * @param name 名称
     */
    public Parent(String name) {
        this.name = name; // this指向当前对象
        this.value = 0;
        System.out.println("父类构造方法执行，name: " + this.name);
    }
    
    /**
     * 父类方法
     */
    public void showInfo() {
        System.out.println("父类showInfo: name=" + this.name + ", value=" + this.value);
    }
    
    /**
     * 父类方法
     */
    public void parentMethod() {
        System.out.println("这是父类的方法");
    }
}

/**
 * 子类，用于演示this和super关键字
 */
class Child extends Parent {
    private int value; // 与父类同名的属性
    
    /**
     * 子类构造方法
     * @param name 名称
     * @param value 值
     */
    public Child(String name, int value) {
        super(name); // super调用父类构造方法，必须是第一行
        this.value = value; // this.value指向子类的value属性
        super.value = value * 2; // super.value指向父类的value属性
        System.out.println("子类构造方法执行，value: " + this.value);
    }
    
    /**
     * 重写父类方法
     */
    @Override
    public void showInfo() {
        super.showInfo(); // super调用父类方法
        System.out.println("子类showInfo: 子类value=" + this.value + ", 父类value=" + super.value);
    }
    
    /**
     * 调用父类方法的演示
     */
    public void callParentMethod() {
        System.out.println("\n子类调用父类方法：");
        super.parentMethod(); // 使用super调用父类方法
        this.parentMethod();  // 使用this调用继承的方法（效果相同）
        parentMethod();       // 直接调用（效果相同）
    }
    
    /**
     * 演示this的其他用法
     */
    public Child getThis() {
        return this; // 返回当前对象的引用
    }
    
    /**
     * 演示this调用其他构造方法
     * @param name 名称
     */
    public Child(String name) {
        this(name, 0); // this调用其他构造方法，必须是第一行
    }
}